package io.gitee.loulan_yxq.owner.mybatisPlus.bean;

import io.gitee.loulan_yxq.owner.core.collection.CollTool;

import java.sql.Connection;
import java.util.List;
import java.util.Map;

/*********************************************************
 ** 对sql直接执行的方法类
 ** <br>
 ** 包含select,insert,update,delete。占位符分为两种一种是采用?作为占位符；另外一种是#{}表示参数占位，${}表示sql注入
 ** <br>
 ** Date: Created in 2022/7/8 13:56
 ** @author loulan
 ** @version 0.0.0
 *********************************************************/
public class ExecuteSQLTool {

    /**
     * 执行select查询语句。(参数占位符请使用?(英文)占位)
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param clzz        指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql         要进行执行的sql语句,占位符使用?
     * @param params      占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> List<T> select(Connection conn, boolean isCloseConn, Class<T> clzz, String sql, Object... params) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        List<T> data = executeSQL.getData(sql, clzz, params);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return data;
    }

    /**
     * 执行select查询语句。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param clzz        指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql         要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj         占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> List<T> select(Connection conn, boolean isCloseConn, Class<T> clzz, Object obj, String sql) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        List<T> data = executeSQL.getData(sql, obj, clzz);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return data;
    }

    /**
     * 执行select查询语句【自动关闭连接】。(参数占位符请使用?(英文)占位)
     *
     * @param conn   数据库的连接对象
     * @param clzz   指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql    要进行执行的sql语句,占位符使用?
     * @param params 占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> List<T> select(Connection conn, Class<T> clzz, String sql, Object... params) {
        return select(conn, true, clzz, sql, params);
    }

    /**
     * 执行select查询语句【自动关闭连接】。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn 数据库的连接对象
     * @param clzz 指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql  要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj  占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> List<T> select(Connection conn, Class<T> clzz, Object obj, String sql) {
        return select(conn, true, clzz, obj, sql);
    }

    /**
     * 执行select查询语句【自动关闭连接】。
     *
     * @param conn 数据库的连接对象
     * @param clzz 指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql  要进行执行的sql语句,不可进行设置占位符
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> List<T> select(Connection conn, Class<T> clzz, String sql) {
        return select(conn, true, clzz, null, sql);
    }

    /**
     * 执行select查询语句【自动关闭连接】。
     *
     * @param conn 数据库的连接对象
     * @param clzz 指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql  要进行执行的sql语句,不可进行设置占位符
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> T selectOne(Connection conn, Class<T> clzz, String sql) {
        return selectOne(conn, true, clzz, null, sql);
    }

    /**
     * 执行select查询语句【自动关闭连接】。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn 数据库的连接对象
     * @param clzz 指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql  要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj  占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> T selectOne(Connection conn, Class<T> clzz, Object obj, String sql) {
        return selectOne(conn, true, clzz, obj, sql);
    }

    /**
     * 执行select查询语句【自动关闭连接】。(参数占位符请使用?(英文)占位)
     *
     * @param conn   数据库的连接对象
     * @param clzz   指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql    要进行执行的sql语句,占位符使用?
     * @param params 占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> T selectOne(Connection conn, Class<T> clzz, String sql, Object... params) {
        return selectOne(conn, true, clzz, sql, params);
    }

    /**
     * 执行select查询语句。(参数占位符请使用?(英文)占位)
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param clzz        指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql         要进行执行的sql语句,占位符使用?
     * @param params      占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> T selectOne(Connection conn, boolean isCloseConn, Class<T> clzz, String sql, Object... params) {
        List<T> data = select(conn, isCloseConn, clzz, sql, params);
        if (CollTool.isNotEmpty(data)) {
            return data.get(0);
        } else {
            return null;
        }
    }

    /**
     * 执行select查询语句。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param clzz        指定类的类对象(类属性请规范使用驼峰式，可使用{@link com.baomidou.mybatisplus.annotation.TableField}和{@link com.baomidou.mybatisplus.annotation.TableId}来指定对应字段名称)
     * @param sql         要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj         占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static <T> T selectOne(Connection conn, boolean isCloseConn, Class<T> clzz, Object obj, String sql) {
        List<T> data = select(conn, isCloseConn, clzz, obj, sql);
        if (CollTool.isNotEmpty(data)) {
            return data.get(0);
        } else {
            return null;
        }
    }

    /**
     * 执行select查询语句。(参数占位符请使用?(英文)占位)
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param isCamel     是否将下划线转换为驼峰式
     * @param sql         要进行执行的sql语句,占位符使用?
     * @param params      占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static List<Map<String, Object>> select(Connection conn, boolean isCloseConn, boolean isCamel, String sql, Object... params) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        List<Map<String, Object>> data = executeSQL.getData(sql, isCamel, params);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return data;
    }

    /**
     * 执行select查询语句。(参数占位符请使用?(英文)占位)
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param isCamel     是否将下划线转换为驼峰式
     * @param sql         要进行执行的sql语句,占位符使用?
     * @param params      占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static Map<String, Object> selectOne(Connection conn, boolean isCloseConn, boolean isCamel, String sql, Object... params) {
        List<Map<String, Object>> dataList = select(conn, isCloseConn, isCamel, sql, params);
        if (CollTool.isNotEmpty(dataList)) {
            return dataList.get(0);
        } else {
            return null;
        }
    }

    /**
     * 执行select查询语句【自动关闭连接，并进行驼峰转换】。(参数占位符请使用?(英文)占位)
     *
     * @param conn   数据库的连接对象
     * @param sql    要进行执行的sql语句,占位符使用?
     * @param params 占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static List<Map<String, Object>> select(Connection conn, String sql, Object... params) {
        return select(conn, true, true, sql, params);
    }

    /**
     * 执行select查询语句【自动关闭连接，并进行驼峰转换】。(参数占位符请使用?(英文)占位)
     *
     * @param conn   数据库的连接对象
     * @param sql    要进行执行的sql语句,占位符使用?
     * @param params 占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static Map<String, Object> selectOne(Connection conn, String sql, Object... params) {
        return selectOne(conn, true, true, sql, params);
    }

    /**
     * 执行select查询语句。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param isCamel     是否将下划线转换为驼峰式
     * @param sql         要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj         占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static List<Map<String, Object>> select(Connection conn, boolean isCloseConn, boolean isCamel, Object obj, String sql) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        List<Map<String, Object>> data = executeSQL.getData(sql, obj, isCamel);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return data;
    }

    /**
     * 执行select查询语句。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param isCamel     是否将下划线转换为驼峰式
     * @param sql         要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj         占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static Map<String, Object> selectOne(Connection conn, boolean isCloseConn, boolean isCamel, Object obj, String sql) {
        List<Map<String, Object>> dataList = select(conn, isCloseConn, isCamel, obj, sql);
        if (CollTool.isNotEmpty(dataList)) {
            return dataList.get(0);
        } else {
            return null;
        }
    }

    /**
     * 执行select查询语句【自动关闭连接，并进行驼峰转换】。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj  占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static List<Map<String, Object>> select(Connection conn, Object obj, String sql) {
        return select(conn, true, true, obj, sql);
    }

    /**
     * 执行select查询语句【自动关闭连接，并进行驼峰转换】。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj  占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static Map<String, Object> selectOne(Connection conn, Object obj, String sql) {
        return selectOne(conn, true, true, obj, sql);
    }

    /**
     * 执行select查询语句【自动关闭连接，并进行驼峰转换】。
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,不可进行设置占位符
     * @return 查询到的数据
     * @author :loulan
     */
    public static List<Map<String, Object>> select(Connection conn, String sql) {
        return select(conn, true, true, null, sql);
    }

    /**
     * 执行select查询语句【自动关闭连接，并进行驼峰转换】。
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,不可进行设置占位符
     * @return 查询到的数据
     * @author :loulan
     */
    public static Map<String, Object> selectOne(Connection conn, String sql) {
        return selectOne(conn, true, true, null, sql);
    }


    /******************************************************************************************************************************************/

    /**
     * 执行插入语句。(参数占位符请使用?(英文)占位)
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param sql         要进行执行的sql语句,占位符使用?
     * @param params      占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 插入数据的条数
     * @author :loulan
     */
    public static int insert(Connection conn, boolean isCloseConn, String sql, Object... params) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        int result = executeSQL.fixData(sql, params);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return result;
    }

    /**
     * 执行插入语句【默认关闭连接】。(参数占位符请使用?(英文)占位)
     *
     * @param conn   数据库的连接对象
     * @param sql    要进行执行的sql语句,占位符使用?
     * @param params 占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 插入数据的条数
     * @author :loulan
     */
    public static int insert(Connection conn, String sql, Object... params) {
        return insert(conn, true, sql, params);
    }

    /**
     * 执行插入语句。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param sql         要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj         占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static int insert(Connection conn, boolean isCloseConn, Object obj, String sql) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        int result = executeSQL.fixData(obj, sql);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return result;
    }

    /**
     * 执行插入语句【默认关闭连接】。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj  占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static int insert(Connection conn, Object obj, String sql) {
        return insert(conn, true, obj, sql);
    }

    /**
     * 执行插入语句【默认关闭连接】。
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,不可进行设置占位符
     * @return 查询到的数据
     * @author :loulan
     */
    public static int insert(Connection conn, String sql) {
        return insert(conn, true, null, sql);
    }

    /******************************************************************************************************************************************/

    /**
     * 执行更新语句。(参数占位符请使用?(英文)占位)
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param sql         要进行执行的sql语句,占位符使用?
     * @param params      占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 更新数据的条数
     * @author :loulan
     */
    public static int update(Connection conn, boolean isCloseConn, String sql, Object... params) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        int result = executeSQL.fixData(sql, params);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return result;
    }

    /**
     * 执行更新语句【默认关闭连接】。(参数占位符请使用?(英文)占位)
     *
     * @param conn   数据库的连接对象
     * @param sql    要进行执行的sql语句,占位符使用?
     * @param params 占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 更新数据的条数
     * @author :loulan
     */
    public static int update(Connection conn, String sql, Object... params) {
        return update(conn, true, sql, params);
    }

    /**
     * 执行更新语句。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param sql         要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj         占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static int update(Connection conn, boolean isCloseConn, Object obj, String sql) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        int result = executeSQL.fixData(obj, sql);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return result;
    }

    /**
     * 执行更新语句【默认关闭连接】。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj  占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static int update(Connection conn, Object obj, String sql) {
        return update(conn, true, obj, sql);
    }

    /**
     * 执行更新语句【默认关闭连接】。
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,不可进行设置占位符
     * @return 查询到的数据
     * @author :loulan
     */
    public static int update(Connection conn, String sql) {
        return update(conn, true, null, sql);
    }

    /******************************************************************************************************************************************/

    /**
     * 执行删除语句。(参数占位符请使用?(英文)占位)
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param sql         要进行执行的sql语句
     * @param params      占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 删除数据的条数
     * @author :loulan
     */
    public static int delete(Connection conn, boolean isCloseConn, String sql, Object... params) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        int result = executeSQL.fixData(sql, params);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return result;
    }

    /**
     * 执行删除语句【默认关闭连接】。(参数占位符请使用?(英文)占位)
     *
     * @param conn   数据库的连接对象
     * @param sql    要进行执行的sql语句
     * @param params 占位符所替换的参数，按顺序进行替换，请确保替换的参数数据类型和数据库数据类型可进行匹配。(参数可以比占位符多，但是不能少)
     * @return 删除数据的条数
     * @author :loulan
     */
    public static int delete(Connection conn, String sql, Object... params) {
        return delete(conn, true, sql, params);
    }

    /**
     * 执行删除语句。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn        数据库的连接对象
     * @param isCloseConn 执行完成之后是否关闭连接
     * @param sql         要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj         占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static int delete(Connection conn, boolean isCloseConn, Object obj, String sql) {
        ExecuteSQL executeSQL = ExecuteSQL.instance(conn);
        int result = executeSQL.fixData(obj, sql);
        if (isCloseConn) {
            executeSQL.close();
        }
        executeSQL = null;
        return result;
    }

    /**
     * 执行删除语句【默认关闭连接】。(#{}表示参数占位，${}表示sql注入)。如果占位符找不到对应的数据那么直接抛出异常
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,占位符使用 #{}和${}
     * @param obj  占位符所替换的参数,可以为实体类对象，也可以是Map集合。(参数可以比占位符多，但是不能少)
     * @return 查询到的数据
     * @author :loulan
     */
    public static int delete(Connection conn, Object obj, String sql) {
        return delete(conn, true, obj, sql);
    }

    /**
     * 执行删除语句【默认关闭连接】。
     *
     * @param conn 数据库的连接对象
     * @param sql  要进行执行的sql语句,不可进行设置占位符
     * @return 查询到的数据
     * @author :loulan
     */
    public static int delete(Connection conn, String sql) {
        return delete(conn, true, null, sql);
    }

    /******************************************************************************************************************************************/
}
